{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "24c787ab",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-05-07 11:30:28.001760: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcudart.so.11.0'; dlerror: libcudart.so.11.0: cannot open shared object file: No such file or directory\n",
      "2024-05-07 11:30:28.001841: I tensorflow/stream_executor/cuda/cudart_stub.cc:29] Ignore above cudart dlerror if you do not have a GPU set up on your machine.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.8.4\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import PIL.Image\n",
    "import tensorflow as tf\n",
    "import pathlib\n",
    "from tensorflow import keras\n",
    "\n",
    "print(tf.__version__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "4d13f9c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "current dir /home/wm\n",
      "change dir\n",
      "/home/wm/statebear/jupyter/tensorflow/mnist\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/wm/py39_tf/lib/python3.9/site-packages/IPython/core/magics/osm.py:417: UserWarning: using dhist requires you to install the `pickleshare` library.\n",
      "  self.shell.db['dhist'] = compress_dhist(dhist)[-100:]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'/home/wm/statebear/jupyter/tensorflow/mnist'"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " # 切换目录\n",
    "c_dir = %pwd\n",
    "print(\"current dir\",c_dir)\n",
    "if ('mnist' not in c_dir):\n",
    "    print(\"change dir\")\n",
    "    %cd statebear/jupyter/tensorflow/mnist\n",
    "%pwd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "d7f6563f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "seed: 294\n",
      "Found 2429 files belonging to 16 classes.\n",
      "Using 1944 files for training.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-05-07 11:30:34.125626: W tensorflow/stream_executor/platform/default/dso_loader.cc:64] Could not load dynamic library 'libcuda.so.1'; dlerror: libcuda.so.1: cannot open shared object file: No such file or directory\n",
      "2024-05-07 11:30:34.125693: W tensorflow/stream_executor/cuda/cuda_driver.cc:269] failed call to cuInit: UNKNOWN ERROR (303)\n",
      "2024-05-07 11:30:34.125715: I tensorflow/stream_executor/cuda/cuda_diagnostics.cc:156] kernel driver does not appear to be running on this host (DESKTOP-VETER3I): /proc/driver/nvidia/version does not exist\n",
      "2024-05-07 11:30:34.125975: I tensorflow/core/platform/cpu_feature_guard.cc:151] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 FMA\n",
      "To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Found 2429 files belonging to 16 classes.\n",
      "Using 485 files for validation.\n"
     ]
    }
   ],
   "source": [
    "from enable_mnist import load_data\n",
    "#训练批次大小\n",
    "batch_size = 32\n",
    "# 图像打下\n",
    "img_height = 28\n",
    "img_width = 28\n",
    "#训练数据集 \n",
    "train_ds,val_ds = load_data(\"category\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "805209ba",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<BatchDataset element_spec=(TensorSpec(shape=(None, 28, 28, 1), dtype=tf.float32, name=None), TensorSpec(shape=(None,), dtype=tf.int32, name=None))>\n",
      "['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'hr', 'p', 'r', 'w', 'wr', 'ww']\n"
     ]
    }
   ],
   "source": [
    "print(val_ds)\n",
    "class_names = train_ds.class_names\n",
    "print(class_names)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "b83d9252",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "16\n"
     ]
    }
   ],
   "source": [
    "# 输出类别数\n",
    "num_classes = len(class_names)\n",
    "print(num_classes)\n",
    "#神经网络配置\n",
    "model = tf.keras.Sequential([\n",
    "  tf.keras.Input([img_width,img_height,1]),\n",
    "#   tf.keras.layers.experimental.preprocessing.RandomRotation(0.02),\n",
    "     tf.keras.layers.Rescaling(1./255),\n",
    "     tf.keras.layers.Conv2D(16, 3, activation='relu'),\n",
    "      tf.keras.layers.MaxPooling2D(),\n",
    "      tf.keras.layers.Conv2D(32, 3, activation='relu'),\n",
    "      tf.keras.layers.MaxPooling2D(),\n",
    "    tf.keras.layers.Flatten(),\n",
    "    tf.keras.layers.Dense(512, activation='relu'),\n",
    "  tf.keras.layers.Dropout(0.1),\n",
    "  tf.keras.layers.Dense(128, activation='relu'),\n",
    "    tf.keras.layers.Dropout(0.1),\n",
    "   #tf.keras.layers.Dense(num_classes,activation=tf.nn.softmax),\n",
    "  tf.keras.layers.Dense(num_classes)\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "c1d6c95c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#训练定义损失函数\n",
    "model.compile(\n",
    "    optimizer= keras.optimizers.Adam(learning_rate=0.001),\n",
    "    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),\n",
    "    metrics=[keras.metrics.SparseCategoricalAccuracy(name='accuracy')]\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5674486f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Model: \"sequential\"\n",
      "_________________________________________________________________\n",
      " Layer (type)                Output Shape              Param #   \n",
      "=================================================================\n",
      " rescaling (Rescaling)       (None, 28, 28, 1)         0         \n",
      "                                                                 \n",
      " conv2d (Conv2D)             (None, 26, 26, 16)        160       \n",
      "                                                                 \n",
      " max_pooling2d (MaxPooling2D  (None, 13, 13, 16)       0         \n",
      " )                                                               \n",
      "                                                                 \n",
      " conv2d_1 (Conv2D)           (None, 11, 11, 32)        4640      \n",
      "                                                                 \n",
      " max_pooling2d_1 (MaxPooling  (None, 5, 5, 32)         0         \n",
      " 2D)                                                             \n",
      "                                                                 \n",
      " flatten (Flatten)           (None, 800)               0         \n",
      "                                                                 \n",
      " dense (Dense)               (None, 512)               410112    \n",
      "                                                                 \n",
      " dropout (Dropout)           (None, 512)               0         \n",
      "                                                                 \n",
      " dense_1 (Dense)             (None, 128)               65664     \n",
      "                                                                 \n",
      " dropout_1 (Dropout)         (None, 128)               0         \n",
      "                                                                 \n",
      " dense_2 (Dense)             (None, 16)                2064      \n",
      "                                                                 \n",
      "=================================================================\n",
      "Total params: 482,640\n",
      "Trainable params: 482,640\n",
      "Non-trainable params: 0\n",
      "_________________________________________________________________\n"
     ]
    }
   ],
   "source": [
    "model.summary()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "6e511160",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/20\n",
      "61/61 [==============================] - 2s 20ms/step - loss: 1.4192 - accuracy: 0.5586 - val_loss: 0.5148 - val_accuracy: 0.8433\n",
      "Epoch 2/20\n",
      "61/61 [==============================] - 1s 16ms/step - loss: 0.4525 - accuracy: 0.8693 - val_loss: 0.2979 - val_accuracy: 0.9113\n",
      "Epoch 3/20\n",
      "61/61 [==============================] - 1s 15ms/step - loss: 0.2844 - accuracy: 0.9146 - val_loss: 0.2305 - val_accuracy: 0.9340\n",
      "Epoch 4/20\n",
      "61/61 [==============================] - 1s 17ms/step - loss: 0.1566 - accuracy: 0.9486 - val_loss: 0.2163 - val_accuracy: 0.9485\n",
      "Epoch 5/20\n",
      "61/61 [==============================] - 1s 15ms/step - loss: 0.1219 - accuracy: 0.9583 - val_loss: 0.2017 - val_accuracy: 0.9464\n",
      "Epoch 6/20\n",
      "61/61 [==============================] - 1s 16ms/step - loss: 0.0799 - accuracy: 0.9769 - val_loss: 0.1593 - val_accuracy: 0.9567\n",
      "Epoch 7/20\n",
      "61/61 [==============================] - 1s 15ms/step - loss: 0.0490 - accuracy: 0.9846 - val_loss: 0.1776 - val_accuracy: 0.9546\n",
      "Epoch 8/20\n",
      "61/61 [==============================] - 1s 15ms/step - loss: 0.0455 - accuracy: 0.9871 - val_loss: 0.1531 - val_accuracy: 0.9588\n",
      "Epoch 9/20\n",
      "61/61 [==============================] - 1s 16ms/step - loss: 0.0312 - accuracy: 0.9892 - val_loss: 0.1537 - val_accuracy: 0.9567\n",
      "Epoch 10/20\n",
      "61/61 [==============================] - 1s 15ms/step - loss: 0.0187 - accuracy: 0.9954 - val_loss: 0.1685 - val_accuracy: 0.9629\n",
      "Epoch 11/20\n",
      "61/61 [==============================] - 1s 15ms/step - loss: 0.0259 - accuracy: 0.9913 - val_loss: 0.1700 - val_accuracy: 0.9526\n",
      "Epoch 12/20\n",
      "61/61 [==============================] - 1s 16ms/step - loss: 0.0340 - accuracy: 0.9907 - val_loss: 0.1570 - val_accuracy: 0.9649\n",
      "Epoch 13/20\n",
      "61/61 [==============================] - 1s 17ms/step - loss: 0.0255 - accuracy: 0.9913 - val_loss: 0.1901 - val_accuracy: 0.9649\n",
      "Epoch 14/20\n",
      "61/61 [==============================] - 1s 15ms/step - loss: 0.0273 - accuracy: 0.9918 - val_loss: 0.1630 - val_accuracy: 0.9629\n",
      "Epoch 15/20\n",
      "61/61 [==============================] - 1s 16ms/step - loss: 0.0183 - accuracy: 0.9943 - val_loss: 0.1533 - val_accuracy: 0.9732\n",
      "Epoch 16/20\n",
      "61/61 [==============================] - 1s 18ms/step - loss: 0.0069 - accuracy: 0.9990 - val_loss: 0.1541 - val_accuracy: 0.9670\n",
      "Epoch 17/20\n",
      "61/61 [==============================] - 1s 15ms/step - loss: 0.0084 - accuracy: 0.9974 - val_loss: 0.1557 - val_accuracy: 0.9670\n",
      "Epoch 18/20\n",
      "61/61 [==============================] - 1s 16ms/step - loss: 0.0090 - accuracy: 0.9985 - val_loss: 0.1692 - val_accuracy: 0.9608\n",
      "Epoch 19/20\n",
      "61/61 [==============================] - 1s 15ms/step - loss: 0.0107 - accuracy: 0.9959 - val_loss: 0.1622 - val_accuracy: 0.9732\n",
      "Epoch 20/20\n",
      "61/61 [==============================] - 1s 15ms/step - loss: 0.0104 - accuracy: 0.9969 - val_loss: 0.1624 - val_accuracy: 0.9691\n"
     ]
    }
   ],
   "source": [
    "from tensorflow.keras.callbacks import EarlyStopping\n",
    "\n",
    "early_stopping = EarlyStopping(monitor='val_accuracy', patience=5, verbose=1)\n",
    "\n",
    "#开始训练\n",
    "normal_history = model.fit(\n",
    "  train_ds,#训练数据\n",
    "  validation_data=val_ds,#验证数据\n",
    "  epochs=20, # 训练次数\n",
    "    # callbacks=[early_stopping]\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "fcbe4fcd",
   "metadata": {},
   "outputs": [],
   "source": [
    "#model.evaluate(x_test, y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "a1e28124",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: /tmp/tmpzzc8ogr6/assets\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: /tmp/tmpzzc8ogr6/assets\n"
     ]
    },
    {
     "ename": "",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m在当前单元格或上一个单元格中执行代码时 Kernel 崩溃。\n",
      "\u001b[1;31m请查看单元格中的代码，以确定故障的可能原因。\n",
      "\u001b[1;31m单击<a href='https://aka.ms/vscodeJupyterKernelCrash'>此处</a>了解详细信息。\n",
      "\u001b[1;31m有关更多详细信息，请查看 Jupyter <a href='command:jupyter.viewOutput'>log</a>。"
     ]
    }
   ],
   "source": [
    "#保存训练结果\n",
    "#tf.saved_model.save(model,\"testsavemodel\")\n",
    "#转换为ftlite 文件，供移动设备使用\n",
    "#convert= tf.lite.TFLiteConverter.from_saved_model(\"testsavemodel\")\n",
    "converter = tf.lite.TFLiteConverter.from_keras_model(model)\n",
    "ftlite_model=converter.convert()\n",
    "open(\"./xc.tflite\",\"wb\").write(ftlite_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d88c310",
   "metadata": {},
   "outputs": [],
   "source": [
    "#probability_model = tf.keras.Sequential([model, tf.keras.layers.Softmax()])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "25206f86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "255.0\n",
      "255.0\n",
      "tf.Tensor(\n",
      "[1.19777305e-05 1.18733093e-04 2.18888567e-06 1.56706164e-06\n",
      " 4.77614667e-05 4.96476105e-06 1.49157122e-05 3.00082183e-06\n",
      " 8.89914918e-06 2.66932966e-06 1.29626234e-04 8.17277760e-06\n",
      " 9.99591768e-01 3.45878630e-06 1.85651879e-05 3.17594604e-05], shape=(16,), dtype=float32)\n",
      "99.95917677879333\n",
      "12\n",
      "r\n"
     ]
    }
   ],
   "source": [
    "\n",
    "\n",
    "img = tf.keras.utils.load_img(\n",
    "    \"./test/3.png\", target_size=(img_height, img_width),color_mode='grayscale'\n",
    ")\n",
    "img_array = tf.keras.utils.img_to_array(img)\n",
    "print(np.max(img_array))\n",
    "\n",
    "img_array = tf.expand_dims(img_array, 0) # Create a batch\n",
    "#img_array = normalization_layer(img_array)\n",
    "print(np.max(img_array))\n",
    "predictions = model.predict(img_array)\n",
    "score = tf.nn.softmax(predictions[0])\n",
    "print(score)\n",
    "print(100 * np.max(score))\n",
    "print(np.argmax(score))\n",
    "print(class_names[np.argmax(score)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "133dfa11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "# 7、画图\n",
    "# 画出 model1 验证集准确率曲线图\n",
    "\n",
    "\n",
    "plt.plot(normal_history.epoch ,normal_history.history['val_accuracy'], c='b',label = 'val_accuracy')\n",
    "\n",
    "plt.plot(normal_history.epoch ,normal_history.history['val_loss'], c='y',label = 'val_loss')\n",
    "\n",
    "plt.plot(normal_history.epoch ,normal_history.history['accuracy'], c='r',label = 'accuracy')\n",
    "\n",
    "plt.plot(normal_history.epoch ,normal_history.history['loss'], c='g',label = 'loss')\n",
    "\n",
    "#plt.plot(np.arange(30), normal_history.history['val_accuracy'], c='b', label='normal')\n",
    "#plt.plot(np.arange(30), dropout_history.history['val_accuracy'], c='y', label='dropout')\n",
    "#       横坐标(0~30)     获取训练结果                               颜色    标签\n",
    "plt.legend()\n",
    " \n",
    "# x 坐标描述\n",
    "plt.xlabel('epochs')\n",
    "# y 坐标描述\n",
    "plt.ylabel('accuracy')\n",
    " \n",
    "# 显示图像\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "375a719b",
   "metadata": {},
   "outputs": [],
   "source": [
    "model.save(\"xcmnistmodel.h5\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6a028905",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "2024-05-07 11:41:24.593503: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "INFO:tensorflow:Assets written to: xcmodel/assets\n"
     ]
    }
   ],
   "source": [
    "tf.saved_model.save(model,'xcmodel')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0aa51123",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.19"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
